<html>
  <head>
    <meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Exploiting Commutativity For Practical Fast Replication | Elvis Zhang</title>
<meta name="description" content="The easy way or the right way." />
<link rel="shortcut icon" href="https://blog.shunzi.tech/favicon.ico">
<link rel="stylesheet" href="https://blog.shunzi.tech/styles/main.css">
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.10.0/katex.min.css">

<script data-ad-client="ca-pub-7661668224317940" async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
<script src="https://blog.shunzi.tech/media/js/jquery.min.js"></script>
<script src="https://blog.shunzi.tech/media/js/masonry.pkgd.min.js"></script>
<script src="https://blog.shunzi.tech/media/js/aos.js"></script>
<script src="https://blog.shunzi.tech/media/js/pace.min.js"></script>
<script src="https://blog.shunzi.tech/media/js/view-image.min.js"></script>
<script src="https://blog.shunzi.tech/media/js/jquery.magnific-popup.min.js"></script>
<script src="https://blog.shunzi.tech/media/js/functions.js"></script>
    <meta name="referrer" content="never">
    <meta name="description" content="

NSDI 2019 的文章《Exploiting Commutativity For Practical Fast Replication》





NSDI 2019 的文章《Exploiting Commutativity For..." />
    <meta name="keywords" content="Paper,存储,分布式" />
    <script src="https://blog.shunzi.tech/media/js/waterfall.min.js"></script>
    <script src="https://blog.shunzi.tech/media/js/prism.min.js"></script>
  </head>
  <body>
            <header id="header" class="grid-container">
        <!-- start: .menu-wrapper -->
        <div class="menu-mobile"> 
          <i class="fa fa-reorder"></i>
        </div>
        <div class="menu-wrapper">
          <div class="">
            <div class="logo">
              <a href="https://blog.shunzi.tech"><img src="\media\images\custom-headerLogo.jpg" alt=""></a>
            </div>
            <!-- start: .main-nav -->

            <nav class="main-nav grid-container grid-parent">
              <ul id="menu-header" class="menu gradient-effect">
                <li class=""><a href="https://blog.shunzi.tech" class="menu">首页</a></li>
                
                  <li class="" >
                    <a href="/archives" class="menu">
                      归档
                    </a>
                  </li>
                
                  <li class="" >
                    <a href="/tag/diary" class="menu">
                      随笔
                    </a>
                  </li>
                
                  <li class="" >
                    <a href="/movies" class="menu">
                      观影
                    </a>
                  </li>
                
                  <li class="" >
                    <a href="/post/about" class="menu">
                      关于
                    </a>
                  </li>
                
                <li class="search-menu-item hide-on-mobile hide-on-tablet"><a href="#search-lightbox" class="lightbox mfp-inline"><i class="fa fa-search-line"></i></a></li>
              </ul>
            </nav>
            <a href="#search-lightbox" class="lightbox epcl-search-button mfp-inline hide-on-tablet hide-on-desktop"><i class="fa fa-search-line"></i></a>
            <!-- end: .main-nav -->
            <div class="clear"></div>
            <div class="border hide-on-tablet hide-on-mobile"></div>
          </div>    
          <div class="clear"></div>
        </div>
        <!-- end: .menu-wrapper -->
        <div class="clear"></div>
      </header>
      <div class="hide-on-mobile hide-on-tablet hide-on-desktop">
        <div id="search-lightbox" class="grid-container grid-small grid-parent mfp-hide">
          <div class="search-wrapper section">
            <form id="gridea-search-form" data-update="1620954331293" action="/search/index.html" class="search-form" _lpchecked="1">
              <input type="text" name="q" id="s" value="" class="search-field" placeholder="搜点啥..." aria-label="搜点啥..." required="">
              <button type="submit" class="submit" aria-label="Submit">
                <i class="fa fa-search-line"></i>
              </button>
            </form>
          </div>
        </div>
      </div>

      <main id="single" class="main grid-container fullcover no-sidebar aos-init aos-animate" data-aos="fade">

        <div class="center content">
          <div class="featured-image cover" style="background-image: url('https://blog.shunzi.tech/post-images/exploiting-commutativity-for-practical-fast-replication.png');">
            <div class="meta top"> 
              <time class="meta-info" style="float:left;" datetime="2019-10-17"><i class="fa fa-calendar"></i><span class="lately">2 年前</span></time>
              
              <a href="https://blog.shunzi.tech/post/exploiting-commutativity-for-practical-fast-replication/#comments" class="comments meta-info" title="">
                <i class="fa fa-comment remixicon"></i><span class="comment-count valine-comment-count" data-xid="/exploiting-commutativity-for-practical-fast-replication/"> </span>
              </a>
              <span id="/exploiting-commutativity-for-practical-fast-replication/" class="leancloud_visitors views-counter meta-info" title=""><i class="fa fa-leancloud remixicon"></i><span class="leancloud-visitors-count"></span></span>
              
            </div>
            <div class="info">
              <div class="tags ">
                
                      <a href="https://blog.shunzi.tech/tag/5uQUdLlSC/" class="ctag ctag-0 ctag-5uQUdLlSC" aria-label="">Paper</a>
                    
                      <a href="https://blog.shunzi.tech/tag/3zCwFWPHxH/" class="ctag ctag-1 ctag-3zCwFWPHxH" aria-label="">存储</a>
                    
                      <a href="https://blog.shunzi.tech/tag/geK0jEW-T/" class="ctag ctag-2 ctag-geK0jEW-T" aria-label="">分布式</a>
                    
              </div>
              <h1 class="title ularge white bold">Exploiting Commutativity For Practical Fast Replication</h1>
            </div>
          </div>
        </div>  

        <div class="epcl-page-wrapper">
          <div class="left-content grid-70 np-mobile">
            <article class="main-article post">
              <section class="post-content">
                <div class="text">
                  <blockquote>
<ul>
<li>NSDI 2019 的文章《Exploiting Commutativity For Practical Fast Replication》</li>
</ul>
</blockquote>
<!-- more -->
<blockquote>
<ul>
<li>NSDI 2019 的文章《Exploiting Commutativity For Practical Fast Replication》</li>
<li>这篇论文主要针对分布式系统中的主从复制场景提供了一种利用执行操作的可交换性快速同步的方案</li>
<li>恰好最近有在学习分布式系统中的一致性以及组会需要讲解论文，故细读了这篇 Paper 并进行总结</li>
<li>由于是研究生期间第一篇细读的论文，想以总结的形式顺便了解到学术论文的相关写作技巧和规范</li>
<li>结合组会交流过程中遇到的几个问题，进行仔细地思考和相关文献资料的查阅，未完待续~</li>
</ul>
</blockquote>
<h2 id="摘要">摘要</h2>
<ul>
<li>传统的数据强一致性场景下的主从复制需要 2RTT（Round-Trip Time）来完成一次操作，而本文提出了一种新的方案 CURP （Consistent Unordered Replication Protocal）实现在 1RTT 内完成一次操作。通过在 Redis 和 RAMCloud 上进行测试：RAMCloud 性能有较大提升，写延迟从 14 微秒降低到 7.1微秒，吞吐量提升约为 4 倍； Redis 的持久化开销也相应地被减小。</li>
<li><strong>编者注</strong>：1RTT 只是针对少量场景能达到的最好效果，一般场景可能仍然需要 2RTT 甚至恶化到 3RTT，所以 1RTT 的说法稍有“标题党”的嫌疑。测试场景主要针对 K-V 型的存储，也是该方案的局限所在，后文具体介绍。</li>
</ul>
<h2 id="introduction">Introduction</h2>
<h3 id="背景">背景</h3>
<ul>
<li>许多分布式系统，特别是分布式存储系统，对可用性和一致性要求都非常高。为了保证服务的高可用，业界往往采用了副本的方式来作为当前服务主节点的“备胎”，但针对部分一致性要求高的场景，需要尽量保证副本的数据和主节点上的数据保持一致。而为了保证一致性，常常都会采用复制的策略，但复制的策略又主体划分为：
<ul>
<li>1.树形复制，也称基于强 Leader 的数据一致性复制协议，诸如 Raft/Multi-Paxos</li>
<li>2.链式复制，链式复制也有相应的优化方案，可参考链接<a href="https://github.com/brpc/braft/blob/master/docs/cn/replication.md"> Github：复制模型</a></li>
<li>3.分发复制：Client直接向各个节点直接进行分发写入，节点之间并不进行通信复制，只要写入多数节点成功，就判为写入成功。</li>
</ul>
</li>
<li>对比以上几种模型，树形复制作为吞吐量和延迟上的折中方案，被很多系统应用到了实际的生产环境中。树形复制流程如图所示，论文主要针对树形复制的 2RTT 进行优化，将其降低为 1RTT，在此基础上提出优化方案。</li>
</ul>
<figure data-type="image" tabindex="1"><img src="https://github.com/brpc/braft/blob/master/docs/images/tree_rep.png?raw=true" alt="image" loading="lazy"></figure>
<h3 id="现有的一些方案">现有的一些方案</h3>
<ul>
<li><strong>复制协议的核心思想</strong>：
<ul>
<li>要保证操作执行顺序的一致性，特别是一些具有因果关系的操作。</li>
<li>需要提供相应的持久化功能，保证能够从故障情况中进行恢复。</li>
</ul>
</li>
</ul>
<h4 id="主从复制-2rtt">主从复制 - 2RTT</h4>
<ul>
<li>传统意义上的主从复制方案，即上文提到的树形复制方案，实现了相应的核心思想，但产生了 2RTT 。</li>
<li>1RTT 来自于 Client 和 Master 之间的交互， 1RTT 来自于 Master 和 Backup 。</li>
<li>该方案中主要依赖 Master 节点对操作进行相应的排序和序列化。</li>
<li>Raft/Multi-Paxos 等基于强 Leader 的数据一致性复制协议，和普通的主从复制的区别仅仅在于复制过程中同步的数据有所不同，Raft/Multi-Paxos 主要针对操作日志进行同步复制。</li>
</ul>
<h4 id="fast-paxos-and-generalized-paxos-15rtt">Fast Paxos and Generalized Paxos - 1.5RTT</h4>
<ul>
<li>该类型方案中不是 Leader 节点来完成对应的序列化操作。</li>
<li>根据推测的执行顺序来进行推断，如果多数节点响应成功，则对应的执行操作。</li>
<li>1RTT 来自于客户端和主节点之间的交互， 0.5RTT 主要来自于等待多数节点同意该顺序。</li>
<li><strong>编者注：</strong> 此处介绍的很抽象模糊，后续会针对这几种 Paxos 算法进行具体的分析比较。</li>
</ul>
<h4 id="network-ordered-paxos-and-speculative-paxos-near-1rtt">Network-Ordered Paxos and Speculative Paxos - Near 1RTT</h4>
<ul>
<li>利用了特殊的网络硬件设施来保证操作的执行顺序。</li>
<li>由于硬件设施的复杂性以及延迟较高，该类型目前而言不太适用于实际生产环境。</li>
</ul>
<h2 id="curp">CURP</h2>
<h3 id="key-idea">Key Idea</h3>
<ul>
<li><strong>Source of Idea</strong>：为了满足一致性复制协议的两个核心思想，性能上往往都差强人意。从需求方面而言，关于持久性的要求为了保证高可用不能做丝毫妥协，则只有在操作的执行顺序上下手进行优化。前有 multi-paxos 基于类似 pipeline 复制的乱序 commit，但是并不能乱序 apply，所以后来又有了 Parallel Raft 通过让 raft 协议感知具体应用而实现乱序 Apply，其实都是想在执行顺序上做些突破。</li>
<li>CURP 采用了一种延迟确定顺序的方案，通过判断操作之间是否有顺序依赖，来区分可以乱序执行的操作和顺序执行的操作，从而实现 1RTT 的延迟。</li>
</ul>
<h3 id="architecture">Architecture</h3>
<figure data-type="image" tabindex="2"><img src="https://github.com/zjs1224522500/files-and-images/blob/master/blog/pic/papers/overview-curp.png?raw=true" alt="image" loading="lazy"></figure>
<h4 id="组成">组成</h4>
<ul>
<li><strong>Client</strong>：并发地向 Primary 和 Witnesses 节点发送 op request，等到 Primary 和 Witnesses 都返回成功了，则认为该请求对应的执行成功。针对某些失败的操作，需要 Client 端针对返回的信息进行相应的处理，同时也有重试的机制。</li>
<li><strong>Primary</strong>：数据操作执行的主节点，也就是副本的 Leader 节点，主节点收到 op request，立马返回执行结果，然后异步地复制给 Backups。其中主节点把持久化的操作划分为了两个区域（或者以状态进行标识），同步区（Synced，图中绿色表示）和未同步区（Unsynced，图中白色表示），便于同步操作的执行。</li>
<li><strong>Backups</strong>：其他副本节点，主要接受来自 Primary 同步或者异步的复制操作。</li>
<li><strong>Witnesses</strong>：节点集群，接收客户端的 op request，将对接收到的请求和节点中已经持久化的 op request 进行交换律的验证，如果满足交换律，则对应的将该操作持久化到该节点中，否则返回 reject，由客户端处理该响应后向 Primary 节点发起 SYNC RPC，主动地触发 Primary 节点向 Backups 节点的复制，大多数副本节点返回成功后对应地向客户端返回成功。</li>
</ul>
<h4 id="witnesses-集群">Witnesses 集群</h4>
<ul>
<li>关于 Witness 节点数量的设置，取决于该模型中副本的个数（除去主副本），从而保证故障恢复情况下，整个系统能对应地表现出相应的容错率。在实际部署过程中，可以考虑 Witness 节点是否和 Backup 节点在一台物理机或者虚拟机上。</li>
<li>为了避免掉电时数据丢失， Witnesses 节点一般部署在 NVM 上，由于是临时数据，数据量不大，且对 IO 执行的速度有一定的要求（响应客户端的请求以及故障恢复时需要较快地读取数据进行恢复），故选择了 NVM 作为存储器件。</li>
</ul>
<h3 id="执行情况描述">执行情况描述</h3>
<h4 id="正常执行可交换的操作执行">正常执行（可交换的操作执行）：</h4>
<figure data-type="image" tabindex="3"><img src="https://github.com/zjs1224522500/files-and-images/blob/master/blog/pic/papers/CURP-Normal-Op.png?raw=true" alt="image" loading="lazy"></figure>
<ul>
<li><strong>Client 端的表现</strong>：并发地发出请求，等待 Primary 和所有的 Witnesses 节点返回成功，则对应的确认该操作成功执行。这种机制也相应地带来了性能瓶颈：<mark>虽说是 1RTT 完成了操作的执行，但是具体的时间可能将取决于 Witenesses 以及 Primary 中最后执行成功的节点，同时还要考虑 Witnesses 节点部分执行成功的情况</mark>。
<ul>
<li>如果 Witnesses 集群中仅有部分节点执行成功，则客户端需要向 Primary 中发起 SYNC RPC调用来进行同步。同接收到 Reject 的响应的结果一样。</li>
</ul>
</li>
<li><strong>Witnesses 节点的操作</strong>：处理来自客户端的 Recored 请求，判断该请求和当前持久化在节点中的请求是否有冲突，没有则继续持久化到节点中，相应地返回 Accepted。</li>
<li><strong>Primary 节点的操作</strong>：执行对应的操作，持久化到节点中，并发送执行成功的响应给客户端，异步地进行主从的复制，并修改该节点中每个操作的同步状态，定期地向 Witnesses 发送 GC 请求。</li>
</ul>
<h4 id="与之前的操作存在冲突时执行">与之前的操作存在冲突时执行：</h4>
<figure data-type="image" tabindex="4"><img src="https://github.com/zjs1224522500/files-and-images/blob/master/blog/pic/papers/CURP-Normal-op-Continued.png?raw=true" alt="image" loading="lazy"></figure>
<ul>
<li><strong>Client 端的表现</strong>：在接收到来自 Witnesses 节点的 Reject 之后，发起 SYNC RPC，让 Primary 节点把其中 Unsynced 的操作进行对应的同步操作，并等待接收同步成功的请求。
<ul>
<li>在处理 Reject 的响应中，整个模型的流程将退化为 2RTT，因为多了一次主从之间的同步操作；但在最坏的场景（发送 SYNC RPC 之后发现 Primary 节点宕机）下可能恶化为 3RTT。</li>
</ul>
</li>
<li><strong>Witnesses 节点的操作</strong>：在判断操作与现有的冲突之后，对应的发送 Reject 的响应，并等待 Primary 节点发起 GC 请求，把 Witnesses 中已经同步了的操作进行清除。</li>
<li><strong>Primary 节点的操作</strong>：先执行对应的操作，持久化到节点中，并发送执行成功的响应给客户端，当收到来自客户端的 SYNC RPC 时，对应地将节点中 Unsynced 的数据同步到副本节点中，并向客户端发送 Synced 响应。</li>
</ul>
<h4 id="读操作的执行">读操作的执行</h4>
<ul>
<li>读操作和写操作的流程大致相同，核心思想都是要先检查读操作和已有的未同步 Unsynced 操作之间是否存在冲突，如果存在则需要 Witnesses 拒绝掉 Record 请求，客户端发送 SYNC RPC来及时进行数据的同步。</li>
</ul>
<h5 id="基于副本数据的一致读实现">基于副本数据的一致读实现</h5>
<ul>
<li><strong>背景</strong>：主从复制的集群中，客户端的读操作往往都是在单节点上进行处理的，由主节点接管对应的读写请求来保证数据的一致性。但往往出于负载的考虑，部分分布式系统允许客户端从副本节点上去读取数据，从而缓解主节点上的压力，以及针对多数据中心的情况，一定程度上减少读取操作的开销，提升其响应操作。</li>
<li><strong>CURP 方案中的问题</strong>：由于 CURP 方案为了提升读写操作的响应速度缩减到 1RTT，所以允许读写操作在完全同步到副本节点之间就完成。这样的机制虽然提高了响应速度，但与此同时也破坏了线性性。</li>
<li><strong>CURP方案中的实现</strong>：为了避免客户端读取到老旧的数据，客户端利用了就近的 Witness 节点（一般为和副本节点在同一台物理机或者虚拟机上的 Witness 节点）来保证数据是最新的。<br>
<img src="https://github.com/zjs1224522500/files-and-images/blob/master/blog/pic/papers/ConsistentReadsFromBackups.png?raw=true" alt="image" loading="lazy"></li>
<li><strong>大致流程</strong>：
<ul>
<li>客户端向副本节点发起读操作之前，需要先向 Witness 节点发起请求询问是否和现有的 Unsynced 操作冲突；</li>
<li>如果不冲突，即此时副本节点上要读取的该数据是最新的，即可以直接向副本节点发起读请求；</li>
<li>如果冲突了，即存在最新的更新还未来得及同步到所有副本节点，故只能从主节点获取最新的数据。</li>
</ul>
</li>
</ul>
<h4 id="故障恢复流程">故障恢复流程</h4>
<h5 id="primary-节点宕机">Primary 节点宕机</h5>
<figure data-type="image" tabindex="5"><img src="https://github.com/zjs1224522500/files-and-images/blob/master/blog/pic/papers/Curp-CRUSH-Recovery.png?raw=true" alt="image" loading="lazy"></figure>
<ul>
<li>故障恢复大致可以分为三个阶段：
<ul>
<li>(1) restoration from backups：首先从 Backups 中选举出新的 Primary 节点，恢复对应的数据</li>
<li>(2) replay from witnesses：从 Witnesses 节点中选取一个节点，要求该节点停止接收客户端请求，进行相应操作的回放，保证数据的一致性</li>
<li>(3) Sync backups and reset witnesses：完成恢复以后，向其他副本节点异步地进行同步，同时重置当前这组 Witnesses 集群，或者要求管理节点分配一组新的 Witnesses 集群。</li>
</ul>
</li>
</ul>
<h5 id="副本节点宕机">副本节点宕机</h5>
<ul>
<li>副本节点宕机和其他非 CURP 模型的处理方式一样，相应地需要将其踢出副本集群，并针对该节点执行后续的故障恢复操作。</li>
</ul>
<h5 id="witnesses-节点宕机">Witnesses 节点宕机</h5>
<ul>
<li>Witness 节点宕机后，将由 系统管理节点 将该节点踢出集群，并分配一个新的 Witness 节点给节点数为 f-1 的 Witnesses 集群，对应的通知 Primary 节点更新其维护的所对应的 Witnesses 集群列表，Primary 节点将还未同步的数据同步到副本节点，相应地触发 GC，告知系统管理节点现在可以正常服务之后，恢复 Witnesses 节点的服务功能。</li>
<li>为了保证客户端维护的 Witnesses 集群信息缓存为最新，使用递增的版本号 <code>WitnessListVersion</code> 来进行控制。每次 Witnesses 集群信息发生改变时，相应地增加版本号，并通知到 Primary 节点。每次客户端向 Master 发起请求时，携带并发访问的 Witnesses 集群版本号，由 Primary 节点来判断是否为最新的 Witnesses 信息，如果不是最新，相应地返回客户端需要更新 Witnesses 集群信息的响应，再由客户端主动拉取 Witnesses 集群信息更新本地缓存。</li>
</ul>
<h4 id="数据迁移">数据迁移</h4>
<ul>
<li>出于负载均衡上的考虑，主节点可能将自己的数据拆分成两个分区上的数据，并把部分数据迁移到另外一个主节点上。</li>
</ul>
<h5 id="迁移的流程">迁移的流程</h5>
<ul>
<li>在处理相关服务请求的同时z准备拷贝数据；</li>
<li>暂停该节点的相关服务进行数据迁移。</li>
</ul>
<h5 id="其他节点">其他节点</h5>
<ul>
<li>为了简化数据迁移的场景以及减小数据迁移带来的不可靠因素的影响，在进行最后的数据迁移操作之前，主节点需要先将该节点上未同步的数据及时进行同步，确保副本节点上数据最新。</li>
<li>针对客户端可能访问到原有的主节点的情况，此时原主节点拒绝一切来自客户端的请求，并获取最新的主节点信息返回给客户端，告知其最新的集群信息，然后客户端向新的集群发起该次操作的重试。</li>
</ul>
<h3 id="核心操作的实现">核心操作的实现</h3>
<h4 id="witnesses-节点如何判断操作之间是否有冲突">Witnesses 节点如何判断操作之间是否有冲突？</h4>
<ul>
<li><mark>本篇 Paper 提出的模型只能针对 <strong>能够进行顺序依赖判断的简单操作</strong> 进行优化，如 KV 型的 IO 操作，可以简单地通过比较每次操作的 KEY 是否相同来进行判断，使用简单的 HASH 函数即可实现。而针对部分需要先进行计算之后才能判断是否具有依赖关系的操作不能进行很好的判断。例如 SQL 语句使用了不同的限定条件（“UPDATE T SET<br>
rate = 40 WHERE level = 3” and “UPDATE T SET<br>
rate = rate + 10 WHERE dept = SDE”）</mark></li>
</ul>
<h4 id="witnesses-节点在出现数据不一致的情况下如何进行处理">Witnesses 节点在出现数据不一致的情况下如何进行处理？</h4>
<ul>
<li>Client 需要等待所有的 Witnesses 节点 Record 成功之后才会进行下一步操作，如果其中接收到了任何一个 Reject 操作，都会调用 SYNC RPC 来进行主从同步复制。</li>
<li>在故障恢复过程中，只会从 Witenesses 节点中选择一个节点来进行操作的回放操作，所以也避免了不一致的情况。</li>
</ul>
<h4 id="故障恢复过程中如何避免操作重复执行">故障恢复过程中如何避免操作重复执行？</h4>
<ul>
<li>CURP 利用了 RIFL 提供的保证只执行一次的机制。在 RIFL 中，客户端会为每一次 RPC 调用分配一个全局唯一标识 ID，在 Server 端对应的记录已经完成的 RPC 调用的 ID，从而便于之后恢复过程中对该操作是否执行过进行判断。</li>
</ul>
<h4 id="gc-垃圾回收的时机">GC 垃圾回收的时机</h4>
<ul>
<li>Primary 节点会根据 Synced 的操作请求的 RPC ID，向 Witnesses 节点发起 GC 的请求，批量地进行垃圾回收以减小 Witnesses 中冲突的可能性。</li>
</ul>
<h3 id="在-nosql-中的实现">在 NoSQL 中的实现</h3>
<h4 id="witness-的生命周期和需要执行的操作">Witness 的生命周期和需要执行的操作</h4>
<pre><code>// CLIENT TO WITNESS:
record(masterID, list of keyHash, rpcId, request) -&gt; ! {ACCEPTED or REJECTED}
// Saves the client request (with rpcId) of an update on keyHashes.
// Returns whether the witness could accomodate and save the request.

// MASTER TO WITNESS:
gc(list of {keyHash, rpcId}) -&gt; list of request
// Drops the saved requests with the given keyHashes and rpcIds. 
// Returns stale requests that haven’t been garbage collected for a long time.

getRecoveryData() -&gt; list of request
// Returns all requests saved for a particular crashed master.

// CLUSTER COORDINATOR TO WITNESS:
start(masterId) -&gt; {SUCCESS or FAIL}
// Start a witness instance for the given master, and return SUCCESS. 
// If the server fails to create the instance, FAIL is returned.

end() -&gt; NULL
// This witness is decommissioned. Destruct itself
</code></pre>
<h4 id="witness-的数据结构">Witness 的数据结构</h4>
<ul>
<li>Witness 的写入操作类似于缓存的级联操作，一次 Witness 的写入请求，会对应地将该请求中操纵的对象的主键进行 HASH（64位哈希值），然后根据哈希值计算当前 Witness 节点中是否已存在 Slot（比较哈希值），即是否存在操作同一个对象的请求。如果有说明操作冲突相应地拒绝掉该请求，没有则对应地写入该操作。</li>
</ul>
<h4 id="主节点上的操作可交换性检查冲突检测">主节点上的操作可交换性检查（冲突检测）</h4>
<ul>
<li>由于 CURP 中的主节点存储的数据存在两种状态，SYNCED 和 UNSYNCED。故主节点可以通过判断操作的的数据对象的状态是否已同步来判断出该操作是否会冲突。</li>
<li>如果操作的对象的实际值是以日志的形式存储的，主节点可以通过比较日志中上次同步的位置和对象存储的值的现在的位置来比较。</li>
<li>如果操作的对象的实际值不是以日志的形式存储的，主节点可以利用单调递增的时间戳来进行比较判断。当主节点更新对象的值后，对应地更新一条元数据信息，类似于最近修改时间一样的时间戳属性，同时主节点也要记录最近一次同步的开始时间戳，通过比较这两个时间戳来判断是否已同步。</li>
</ul>
<h4 id="curp-提高主节点的吞吐量方式">CURP 提高主节点的吞吐量方式</h4>
<ul>
<li>由于主从复制集群中，主节点往往是整个集群的性能瓶颈，故为了提高主节点的吞吐量，CURP 采用了以下几种方式：</li>
</ul>
<h5 id="进行批量同步操作">进行批量同步操作</h5>
<ul>
<li>CURP 中采用了延迟同步的策略，所以不用每次操作之后都进行相应的同步操作。在无冲突异步复制的场景下，设定一个阈值，当主节点中 Unsynced 的数据个数达到该阈值时才对应地触发同步操作；在存在冲突主动复制的场景下，将此时主节点中未同步的数据全部进行同步（一般小于异步复制时设定的阈值）。</li>
<li>无论哪种场景，都采用了批量同步的情况，避免了频繁的 RPC 调用，从而提高了主节点的吞吐量。</li>
<li><strong>注意</strong>：异步复制时的阈值设定，对主节点吞吐量可能造成比较大的影响。当阈值较大时，每一次操作的冲突可能性越大，也就相应地增大了触发同步复制的可能性。所以需要根据具体的IO访问情况，进行阈值相关的测试，寻找到合适的阈值设定来保证主节点吞吐量最大化。</li>
</ul>
<h5 id="非阻塞io">非阻塞IO</h5>
<ul>
<li>相比于其他主从同步的方案，主节点往往都需要等待复制完成后才进行后续的操作，而在CURP的方案中，主节点无需等待复制操作的完成就可以直接进行下一个请求的处理，一定程度上也提升了主节点的吞吐量。</li>
</ul>
<h4 id="gc-垃圾回收的实现">GC 垃圾回收的实现</h4>
<ul>
<li>使用操作对象主键对应的 64 位哈希值和 RIFL 分配的 RpcID 来定位需要回收的垃圾数据，在收到对应的 GC 命令后，使用 keyHash 定位对象所属的 Slot，然后再根据 RpcID 来删除掉匹配的请求数据。</li>
<li>尽管简单的 GC 机制已经可以清除掉绝大多数垃圾，但是针对一些特殊情况如网络上的延迟以及客户端的一些宕机情况导致 Witness 节点存在未能正确清楚的垃圾数据，为了避免造成不一致问题，Witness 提供了相应的检测机制。</li>
<li>由于存在垃圾数据，故新请求被 Reject 的概率增大，如果发现针对某给对象的请求多次遇到冲突被拒绝，Witness 节点就将该对象标记为可能未正确回收的垃圾数据，在下一次主节点发送垃圾回收命令时相应地将这些未回收的数据信息返回给主节点，在下一次垃圾回收时，主节点将一并处理之前未回收的垃圾数据。</li>
</ul>
<h2 id="问题讨论">问题讨论</h2>
<h3 id="1-可不可以让witnesses-节点存储全量的数据不区分操作是否冲突直接异步地进行同步">1. 可不可以让Witnesses 节点存储全量的数据，不区分操作是否冲突，直接异步地进行同步。</h3>
<h3 id="2-witness-节点是以什么样的形式记录操作的为何不合并相关写操作记录最终的写数据">2. Witness 节点是以什么样的形式记录操作的？为何不合并相关写操作，记录最终的写数据？</h3>
<h3 id="3-从设计角度来讲curp方案应该是有很大的尾延迟为什么测试出来的尾延迟反而有提升">3. 从设计角度来讲，CURP方案应该是有很大的尾延迟，为什么测试出来的尾延迟反而有提升？</h3>
<h3 id="4-读过程是否可以进行优化直接读取witness上的数据">4. 读过程是否可以进行优化，直接读取witness上的数据？</h3>
<h3 id="5-多并发写相同数据时系统的运行情况">5. 多并发写相同数据时，系统的运行情况</h3>

                </div>
                <div class="clear"></div>
              </section>
            </article>
            <div class="clear"></div>

            <section class="related section">
              
              <article class="prev grid-50 tablet-grid-50 grid-parent">
                <div class="thumb cover lazy loaded" style="background-image: url('https://github.com/zjs1224522500/files-and-images/blob/master/blog/pic/Arch-SLM-DB.png?raw=true');"></div>
                 <a href="https://blog.shunzi.tech/post/slm-db-single-level-key-value-store-with-persistent-memory/" class="full-link"></a>
                 <div class="info">
                  <time datetime="2019-10-27">2019-10-27</time>
                  <h4 class="title white no-margin">SLM-DB Single-Level Key-Value Store with Persistent Memory</h4>
                </div>
                 <span class="epcl-button red">
                  <img src="https://blog.shunzi.tech/media/images/left-arrow.svg" width="15" alt="Left Arrow">
                </span>
                <div class="overlay"></div>
              </article>
              
              
              <article class="next grid-50 tablet-grid-50 grid-parent">
                <div class="thumb cover lazy loaded" style="background-image: url('https://github.com/zjs1224522500/files-and-images/blob/master/blog/pic/docker-k8s.png?raw=true');"></div>
                 <a href="https://blog.shunzi.tech/post/Docker-Notes/" class="full-link"></a>
                 <div class="info">
                  <time datetime="2019-10-16">2019-10-16</time>
                  <h4 class="title white no-margin">重拾Docker</h4>
                </div>
                 <span class="epcl-button red">
                  <img src="https://blog.shunzi.tech/media/images/right-arrow.svg" width="15" alt="Left Arrow">
                </span>
                <div class="overlay"></div>
              </article>
              

                <div class="clear"></div>
            </section>

              <div class="clear"></div>
              
            
              <div id="comments" class="bg-white hosted ">
                <div class="clear"></div>
<script>
jQuery(document).ready(function($){
    $('.vemoji-btn').text('😀');
    $("#comments").on('click', 'span.vat',function(){
        $(this).parent('div.vmeta').next("div.vcontent").after($("div.vwrap"));
        $('textarea#veditor').focus();
    })
    if(window.location.hash){
        var checkExist = setInterval(function() {
            if ($(window.location.hash).length) {
                $('html, body').animate({scrollTop: $(window.location.hash).offset().top-200}, 600);
                clearInterval(checkExist);
            }
        }, 100);
    }
})
</script>

              </div>
            

            </div>
          </div>
      </main>

          <footer id="footer" class="grid-container">
        <div class="widgets row gradient-effect">
            <div class="default-sidebar border-effect">
              <div class="grid-33 tablet-grid-50 mobile-grid-100">
                <section id="tag_cloud-2" class="widget widget_epcl_posts_thumbs underline-effect">
                  <h4 class="widget-title title white bordered">最新文章</h4>
                  
                  
                  <article class="item post-0 post type-post status-publish format-standard has-post-thumbnail hentry">
                    <a href="https://blog.shunzi.tech/post/cpp-multi-thread/" class="thumb hover-effect">
                      <span class="fullimage cover" style="display:block;border-radius:50%;background-image: url('https://raw.githubusercontent.com/zjs1224522500/PicGoImages/master//img/blog/20210513192958.png');"></span>
                    </a>
                    <div class="info gradient-effect">
                      <time datetime="2021-05-06">2021-05-06</time>
                      <h4 class="title usmall">
                        <a href="https://blog.shunzi.tech/post/cpp-multi-thread/">C++ 多线程</a>
                      </h4>
                    </div>
                    <div class="clear"></div>
                  </article>
                  
                  
                  
                  <article class="item post-1 post type-post status-publish format-standard has-post-thumbnail hentry">
                    <a href="https://blog.shunzi.tech/post/c-basic/" class="thumb hover-effect">
                      <span class="fullimage cover" style="display:block;border-radius:50%;background-image: url('https://raw.githubusercontent.com/zjs1224522500/PicGoImages/master//img/blog/20210513192631.png');"></span>
                    </a>
                    <div class="info gradient-effect">
                      <time datetime="2021-04-06">2021-04-06</time>
                      <h4 class="title usmall">
                        <a href="https://blog.shunzi.tech/post/c-basic/">C 基础</a>
                      </h4>
                    </div>
                    <div class="clear"></div>
                  </article>
                  
                  
                  
                  <article class="item post-2 post type-post status-publish format-standard has-post-thumbnail hentry">
                    <a href="https://blog.shunzi.tech/post/basic-of-concurrency-one/" class="thumb hover-effect">
                      <span class="fullimage cover" style="display:block;border-radius:50%;background-image: url('https://raw.githubusercontent.com/zjs1224522500/PicGoImages/master//img/blog/20200717213648.png');"></span>
                    </a>
                    <div class="info gradient-effect">
                      <time datetime="2021-04-05">2021-04-05</time>
                      <h4 class="title usmall">
                        <a href="https://blog.shunzi.tech/post/basic-of-concurrency-one/">Series Three of Basic of Concurrency - Condition Variables</a>
                      </h4>
                    </div>
                    <div class="clear"></div>
                  </article>
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  <div class="clear"></div>
                </section>
              </div>

              <div class="grid-33 tablet-grid-50 mobile-grid-100">
                <section id="tag_cloud-2" class="widget widget_tag_cloud underline-effect">
                  <h4 class="widget-title title white bordered">标签云</h4>
                  <div class="tagcloud">
                    
                      <a href="https://blog.shunzi.tech/tag/n2w6bz87h/" class="ctag ctag-0 ctag-n2w6bz87h" aria-label="">编程语言</a>
                    
                      <a href="https://blog.shunzi.tech/tag/3zCwFWPHxH/" class="ctag ctag-1 ctag-3zCwFWPHxH" aria-label="">存储</a>
                    
                      <a href="https://blog.shunzi.tech/tag/la-n8a0mo/" class="ctag ctag-2 ctag-la-n8a0mo" aria-label="">读书笔记</a>
                    
                      <a href="https://blog.shunzi.tech/tag/os/" class="ctag ctag-3 ctag-os" aria-label="">OS</a>
                    
                      <a href="https://blog.shunzi.tech/tag/5uQUdLlSC/" class="ctag ctag-4 ctag-5uQUdLlSC" aria-label="">Paper</a>
                    
                      <a href="https://blog.shunzi.tech/tag/_jfuTNqah/" class="ctag ctag-5 ctag-_jfuTNqah" aria-label="">LSM</a>
                    
                      <a href="https://blog.shunzi.tech/tag/hbaTDSglx-/" class="ctag ctag-6 ctag-hbaTDSglx-" aria-label="">工具</a>
                    
                      <a href="https://blog.shunzi.tech/tag/EO3XpMf_y/" class="ctag ctag-7 ctag-EO3XpMf_y" aria-label="">Linux</a>
                    
                      <a href="https://blog.shunzi.tech/tag/wAFV_pvXZ/" class="ctag ctag-8 ctag-wAFV_pvXZ" aria-label="">cs-course</a>
                    
                      <a href="https://blog.shunzi.tech/tag/VqiGqmxbod/" class="ctag ctag-9 ctag-VqiGqmxbod" aria-label="">6.824</a>
                    
                      <a href="https://blog.shunzi.tech/tag/geK0jEW-T/" class="ctag ctag-10 ctag-geK0jEW-T" aria-label="">分布式</a>
                    
                      <a href="https://blog.shunzi.tech/tag/l8sKsLUAi/" class="ctag ctag-11 ctag-l8sKsLUAi" aria-label="">KVS</a>
                    
                      <a href="https://blog.shunzi.tech/tag/9msH-lUaA/" class="ctag ctag-12 ctag-9msH-lUaA" aria-label="">缓存</a>
                    
                      <a href="https://blog.shunzi.tech/tag/i2b42Y2j6/" class="ctag ctag-13 ctag-i2b42Y2j6" aria-label="">Ceph</a>
                    
                      <a href="https://blog.shunzi.tech/tag/oBVOD8v4ou/" class="ctag ctag-14 ctag-oBVOD8v4ou" aria-label="">一致性</a>
                    
                      <a href="https://blog.shunzi.tech/tag/gqgftpk_y/" class="ctag ctag-15 ctag-gqgftpk_y" aria-label="">AI</a>
                    
                      <a href="https://blog.shunzi.tech/tag/shu-ju-ku/" class="ctag ctag-16 ctag-shu-ju-ku" aria-label="">数据库</a>
                    
                      <a href="https://blog.shunzi.tech/tag/ZnIN9Ge-w/" class="ctag ctag-17 ctag-ZnIN9Ge-w" aria-label="">对象存储</a>
                    
                      <a href="https://blog.shunzi.tech/tag/4zx4ysLGro/" class="ctag ctag-18 ctag-4zx4ysLGro" aria-label="">云计算</a>
                    
                      <a href="https://blog.shunzi.tech/tag/Y_nsOD1At/" class="ctag ctag-19 ctag-Y_nsOD1At" aria-label="">SSD</a>
                    
                      <a href="https://blog.shunzi.tech/tag/E2d1yYZcV8/" class="ctag ctag-20 ctag-E2d1yYZcV8" aria-label="">虚拟化</a>
                    
                      <a href="https://blog.shunzi.tech/tag/PhD/" class="ctag ctag-21 ctag-PhD" aria-label="">Ph.D</a>
                    
                      <a href="https://blog.shunzi.tech/tag/ZqEqvRTvl/" class="ctag ctag-22 ctag-ZqEqvRTvl" aria-label="">网络</a>
                    
                      <a href="https://blog.shunzi.tech/tag/PuY19cs53/" class="ctag ctag-23 ctag-PuY19cs53" aria-label="">仿真</a>
                    
                      <a href="https://blog.shunzi.tech/tag/rIIc9E-ZvN/" class="ctag ctag-24 ctag-rIIc9E-ZvN" aria-label="">系统结构</a>
                    
                      <a href="https://blog.shunzi.tech/tag/fu-wu-qi/" class="ctag ctag-25 ctag-fu-wu-qi" aria-label="">服务器</a>
                    
                      <a href="https://blog.shunzi.tech/tag/X-lnqf1Ex/" class="ctag ctag-26 ctag-X-lnqf1Ex" aria-label="">容器</a>
                    
                      <a href="https://blog.shunzi.tech/tag/5h7k39FKw/" class="ctag ctag-27 ctag-5h7k39FKw" aria-label="">C语言</a>
                    
                      <a href="https://blog.shunzi.tech/tag/diary/" class="ctag ctag-28 ctag-diary" aria-label="">Diary</a>
                    
                      <a href="https://blog.shunzi.tech/tag/DyzFtOe6x/" class="ctag ctag-29 ctag-DyzFtOe6x" aria-label="">计算机基础</a>
                    
                      <a href="https://blog.shunzi.tech/tag/oqE3oKihb/" class="ctag ctag-30 ctag-oqE3oKihb" aria-label="">OpenStack</a>
                    
                      <a href="https://blog.shunzi.tech/tag/p_z7gKe6R/" class="ctag ctag-31 ctag-p_z7gKe6R" aria-label="">中间件</a>
                    
                      <a href="https://blog.shunzi.tech/tag/Test/" class="ctag ctag-32 ctag-Test" aria-label="">测试</a>
                    
                      <a href="https://blog.shunzi.tech/tag/Product-Standard/" class="ctag ctag-33 ctag-Product-Standard" aria-label="">Product Standard</a>
                    
                      <a href="https://blog.shunzi.tech/tag/spring/" class="ctag ctag-34 ctag-spring" aria-label="">Spring</a>
                    
                      <a href="https://blog.shunzi.tech/tag/she-ji-mo-shi/" class="ctag ctag-35 ctag-she-ji-mo-shi" aria-label="">设计模式</a>
                    
                      <a href="https://blog.shunzi.tech/tag/mian-jing/" class="ctag ctag-36 ctag-mian-jing" aria-label="">面经</a>
                    
                      <a href="https://blog.shunzi.tech/tag/suan-fa/" class="ctag ctag-37 ctag-suan-fa" aria-label="">算法</a>
                    
                      <a href="https://blog.shunzi.tech/tag/redis/" class="ctag ctag-38 ctag-redis" aria-label="">Redis</a>
                    
                      <a href="https://blog.shunzi.tech/tag/javaweb/" class="ctag ctag-39 ctag-javaweb" aria-label="">JavaWeb</a>
                    
                      <a href="https://blog.shunzi.tech/tag/KyMCZj2Wl/" class="ctag ctag-40 ctag-KyMCZj2Wl" aria-label="">WEB容器</a>
                    
                      <a href="https://blog.shunzi.tech/tag/javase/" class="ctag ctag-41 ctag-javase" aria-label="">JavaSE</a>
                    
                  </div>
                  <div class="clear"></div>
                </section>
              </div>

              <div class="grid-33 tablet-grid-50 mobile-grid-100">
                <section id="epcl_about-2" class="widget widget_epcl_about underline-effect">
                  <h4 class="widget-title title white bordered">关于我</h4>
                  <div class="avatar">
                    <a href="" class="translate-effect thumb"><span class="fullimage cover" style="background-image: url(https://blog.shunzi.tech/images/avatar.png);"></span></a>
                  </div>
                  <div class="info">
                    <h4 class="title small author-name gradient-effect no-margin"><a href="">Elvis Zhang</a></h4>
                    <p class="founder">The easy way or the right way.</p>
                    <div class="social">
                      
                          
                            <a href="https://github.com/zjs1224522500" class="translate-effect" target="_blank"><i class="fa fa-github"></i></a>
                        
                      
                          
                            <a href="https://twitter.com/1224522500Elvis" class="translate-effect" target="_blank"><i class="fa fa-twitter"></i></a>
                        
                      
                        
                      
                        
                      
                        
                      
                    </div> 
                  </div>
                  <div class="clear"></div>
                  </section>
              </div>

            </div>
            <div class="clear"></div>
        </div>

        <div class="logo">
          <a href="https://blog.shunzi.tech"><img src="\media\images\custom-footerLogo.jpg" alt=""></a>
        </div>
        <p class="published border-effect">
          ©2019 共 115 篇文章
          <br/>
          Theme <a href="https://gridea.dev/" target="_blank">「breek」</a> Powered by <a href="https://gridea.dev/" target="_blank">「Gridea」</a>
        </p>
        
        <a href="javascript:void(0)" id="back-to-top" class="epcl-button dark" style="display:none">
          <i class="fa fa-arrow"></i>
        </a>
    </footer>
    
    <div class="clear"></div>

        
<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/leancloud-storage/dist/av-min.js"></script>
<script type="text/javascript" src="https://cdn.staticfile.org/valine/1.3.10/Valine.Pure.min.js"></script>
<script>
    new Valine({
        el: '#comments',
        appId: 'Pj5H1z0w7hJlLGJpGBh9NrCq-MdYXbMMI' ,
        appKey: 'LdR8vK5EaBfK87esF7tlbsXe',
        pageSize: 30,
        placeholder: '既然来了，那就留个痕迹吧~',
        visitor: true // 阅读量统计
    })
</script>
    

      
    <script src="https://blog.shunzi.tech/media/js/functions-post.js"></script>

    </div>
    <!-- end: #wrapper -->
  </body>
</html>
